MacTech 1 to 12/MacTech-vol-1-12.toast/Source/MacTech® Magazine/Volume 12 - 1996/12.05 May 96/Java

Text File | 1996-04-19 | 10.5 KB | 303 lines | [TEXT/R*ch]

Our first Java application will display the obligatory “Hello, world!”  message:

public class hello
{
    public static void main(String argv[])
    {
        System.out.println("Hello, world!");
    }
}

Create a new file, type in this code, then save the file as hello.java.  Just as
you’d end your C source code file with the extension .c and your C++ source code
file with .cp or .cpp, the extension .java is used to denote a Java source code
file.
If you are using the JDK, drag the file hello.java onto the application named
Java Compiler (gee, guess what this is).  The compiler will convert your source
code into Java byte code, intended for a Java interpreter that will turn these
byte codes into the instructions specific to the machine it is running on.  The
interpreter is part of the virtual machine, the layer that lies between the
platform-independent Java byte code and your machine.
The compiler writes the Java byte code into a file named xxx.class, where xxx is
the name of the class you’ve implemented.  In this case, the compiler will
create a file called hello.class.  Again, if you are using the JDK, drag the
file hello.class onto the application named Applet Viewer.  As you might expect,
the Applet Viewer will start running at the public method named main().
The output of this application is shown in Figure 1.  Notice that the window is
named stdout.  If you’ve ever spent any time in the Unix universe, you know that
stdout stands for “standard output”.  The method System.out.println() sends its
output to the stdout window followed by a carriage return.  The method
System.out.print() sends its output to the stdout window without generating a
carriage return.

Figure 1.  The output from the hello.class application
System.out.println() is a lot like printf() or cout in that they all send their
output to a console window.  Just as you first learned to program using consoles
and eventually moved to the Mac Toolbox for your user interface, we’ll start
with System.out.println() and eventually move on to the user interface routines
in the AWT (advanced windowing toolkit).  You’ll use the AWT to implement a user
interface you’ll want to appear on a web page.
Don’t worry too much about the structure of our Java source code just yet.  The
three applications in this month’s column all use the same basic structure: a
class wrapper with a single public method called main().  Oh yeah, in Java, a
class’ functions are called methods instead of member functions.
Your Second Application: StringTester
Our second application, stringTester, introduces an important Java data type:
String.  As its name suggests, the String class was implemented to work with
strings.  Unlike C and Pascal strings, a Java String is an object, complete with
variables (the Java term for data members) and methods.  Our third applica-tion,
stringMethods, will demonstrate some of the String methods.  This application,
stringTester, will get us started.
Here’s the source...

public class stringTester
{
    public static void main(String argv[])
    {
        String    string1, string2 = ", world!";

        string1 = "Hello";

        System.out.print( string1 );
        System.out.println( string2 );
        System.out.println( string1 + string2 );

        string1 += string2;
        System.out.println( string1 );

        System.out.println( "Length of this string: " +
                            string1.length() );
    }
}

The first few lines show you two ways to create and initialize a String:

        String    string1, string2 = ", world!";

        string1 = "Hello";

You can initialize the String when you define it or you can use the assignment
operator, as we did in the second line.  Nothing unusual here.
The next line prints the first string, “Hello”, without a carriage return.  The
second line prints the second string, “, world!”, with a carriage return.

        System.out.print( string1 );
        System.out.println( string2 );

This produces this line of output in the stdout window:

Hello, world!

The next line uses the + operator to concatenate string1 and string2, sending
the joined string as a parameter to println().

        System.out.println( string1 + string2 );

Here’s the output produced by this code:

Hello, world!

Next, the += operator is used to concatenate string2 onto the end of string1 and
the new string1 is send to stdout:

        string1 += string2;
        System.out.println( string1 );

Once again, here is the output:

Hello, world!

Finally, the length() method is called to return the length of the modified
string1.  Notice that the + operator is used to merge the two strings passed to
println() into a single string:

        System.out.println( "Length of this string: " +
                            string1.length() );

Here’s the final line of output:

Length of this string: 13
Your Third Application: StringMethods
Our last application this month demonstrates some of the String methods.  As you
go through this program, take a moment to go through the documentation that came
with your development environment.  In particular, look for the file
java.lang.String.html.  As you’ll see as you learn more about Java, all the Java
classes are part of some larger collection of classes.  These collections take
the form of packages.  For example, the String class (along with the rest of the
“built-in” Java types) are part of the java.lang package.  To use a package, you
use a mechanism similar to the #include.  This mechanism is the import
statement.  We’ll learn about the import statement in next month’s column.  The
one package you automatically have access to is java.lang and so you don’t need
to import it to get access to the String class.
The file java.lang.String.html contains a complete description of the variables
and methods that make up the String class.  Use your Web browser to open this
html file and look over the class.
Here’s the stringMethods source code...

public class stringMethods
{
    public static void main(String argv[])
    {
        char    myArray[] = {'a', 'b', 'c', 'd', 'e'};
        java.lang.String    string = new String( myArray );

        System.out.println( "string: " + string );
        System.out.println( "string[2]: "
                + string.charAt( 2 ) );

        string = string.concat( string );
        System.out.println( "Doubled string: "
                + string );

        System.out.println( "Index of first 'x': "
                + string.indexOf( 'x' ) );

        int    index = string.indexOf( 'e' );
        System.out.println( "Index of first 'e': "
                + index );

        if ( index >= 0 )
            System.out.println( "Index of second 'e': "
                + string.indexOf( 'e', index+1 ) );

        System.out.println( "substring[2] to the end: "
                + string.substring( 2 ) );
        System.out.println( "substring[2] up to string[4]: "
                + string.substring( 2, 4 ) );

        string = string.replace( 'c', 'x' );
        System.out.println( "Replace 'c' with 'x': "
                + string );

        System.out.println( "Display as upper case: "
                + string.toUpperCase() );
    }
}

The first two lines show you yet another way to create a new String.  As you’ll
see when you read through java.lang.String.html, there are several versions of
the String constructor.  Just like C++, Java supports function overloading,
allowing you to create multiple versions of the same function, as long as each
version has a unique signature (the function name combined with the parameter
list).
This line defines an array of chars and initializes the array with the
characters a through e:

        char    myArray[] = {'a', 'b', 'c', 'd', 'e'};

This line uses new to define the new String object, using the char array to
initialize the String to the string “abcde”.  Notice that we refer to
java.lang.String instead of just String.  The two terms are equivalent.  Since
the java.lang package is automatically included, the java.lang prefix is not
needed.

        java.lang.String    string = new String( myArray );

The next line prints this string.  System is actually java.lang.System.
java.lang.System features a variable called out which features methods called
print() and println().  We could have referred to java.lang.System.out.println()
but, again, the java.lang is assumed.

        System.out.println( "string: " + string );

Here’s the output:

string: abcde

This next println() calls the String method charAt().  charAt() returns the nth
character in the String.

        System.out.println( "string[2]: "
                + string.charAt( 2 ) );

Here’s the output.  Note that Java strings are 0-based, just like C and C++.

string[2]: c

The concat() method appends its parameter to the end of the current object.  In
this case, we concat() string on the end of string, storing the result in
string, then print the newly doubled string.

        string = string.concat( string );
        System.out.println( "Doubled string: "
                + string );

Here’s the output...

Doubled string: abcdeabcde

The method indexOf() searches the string for the specified character, returning
either an index into the string or the value -1.

        System.out.println( "Index of first 'x': "
                + string.indexOf( 'x' ) );

Here’s the output.  Since the string doesn’t contain an ‘x’, indexOf() returned
-1.

Index of first 'x': -1

The next lines of code searches for the first ‘e’ in the String, storing the
index in the variable index, then printing the index.

        int    index = string.indexOf( 'e' );
        System.out.println( "Index of first 'e': "
                + index );
Here’s the output:

Index of first 'e': 4

Next, assuming the index was not negative, we use a second version of indexOf()
which takes a second parameter.  This second parameter tells indexOf() where to
start its search in the string, allowing us to search the string for a second
‘e’.

        if ( index >= 0 )
            System.out.println( "Index of second 'e': "
                + string.indexOf( 'e', index+1 ) );

Here’s the output:

Index of second 'e': 9

Next, the substring() method is called.  substring() takes an index into the
string and returns a string that runs from the index to the end of the string.

        System.out.println( "substring[2] to the end: "
                + string.substring( 2 ) );

Here’s the output:

substring[2] to the end: cdeabcde

Next, we call a second version of substring().  This one takes a second
parameter, an index that marks the end of the substring.

        System.out.println( "substring[2] up to string[4]: "
                + string.substring( 2, 4 ) );

Here’s the output:

substring[2] up to string[4]: cd

replace() replaces all occurrences of char 1 with char 2 in the string, then
prints the result.

        string = string.replace( 'c', 'x' );
        System.out.println( "Replace 'c' with 'x': "
                + string );

Here’s the result:

Replace 'c' with 'x': abxdeabxde

toUpperCase() replaces all lower case letters in the string with their upper
case equivalents.

        System.out.println( "Display as upper case: "
                + string.toUpperCase() );

Here’s the result:

Display as upper case: ABXDEABXDE